Machine learning final project - Stock prediction and analysis - team 14¶
Topic¶
股票買賣
判斷應該是要買多還是賣空、預判漲跌，然後使利潤最大化
motivations¶
- 動機：個人利益方面，當然是希望所學能幫自己賺錢。社會方面，因為AI在有些方面已經超越人類了，像是圍棋，而運用在財金方面是否能有顯著的提供協助?財金相較於其他領域是更貼近人們的生活的，因此可能對人類的生活產生巨變，而且投資要考量的變數實在很多，所以我很好奇運用AI技術的投資能否打敗人類。
- 重要性：AI已經有發展到一定的程度了，然而運用AI的領域實在不算多，目前可能只有遊戲、視覺、跟自然語言處理有比較傑出的成果，AI勢必還需要在某些能大大改變人們生活的領域發展，更能顯的AI會如何影響人類。如果AI加上財金將會大大地改變人們的生活，而且投資並不是只有考量數學，還是一門跟人文、心理相關的學問，而AI是否能連這些都考慮到是我所好奇的。
related work¶
- "Global stock market investment strategies based on financial network indicators using machine learning techniques. Lee, Tae Kyun, et al. "Global stock market investment strategies based on financial network indicators using machine learning techniques." Expert Systems with Applications 117 (2019): 228-242.
- "Supporting Investment Management Processes with Machine Learning Techniques." Groth, Sven S., and Jan Muntermann. "Supporting Investment Management Processes with Machine Learning Techniques." Wirtschaftsinformatik (2). 2009.
- "A machine learning model for stock market prediction." Hegazy, Osman, Omar S. Soliman, and Mustafa Abdul Salam. "A machine learning model for stock market prediction." arXiv preprint arXiv:1402.7351 (2014).
- "Predicting stock and stock price index movement using trend deterministic data preparation and machine learning techniques." Patel, Jigar, et al. "Predicting stock and stock price index movement using trend deterministic data preparation and machine learning techniques." Expert systems with applications 42.1 (2015): 259-268.
Formulate the problem.¶
- 起始金額為現金10,000元，希望最後能賺最多錢
- 每天都要判斷買多還是賣多這固定的十檔股票(0050、0056、鴻海、台積電、聯發科、大立光、富邦金、國泰金、玉山金、元大金)
- 自變數會用先前的開盤價、最高價、最低價、收盤價、成交量、5日均價、20日均價、網路聲量(如果有學會爬蟲的話)等等，而變數就是這十檔分別該買還是賣
- 假設想買一定買得到，想脫手一定賣得掉
- 假設股票能以前一天的收盤價買進，融券也是以前一天的收盤價為代價
- 假設手續費為交易金額的0.1%
- 先預測哪些會漲那些會跌之後，在認為漲超過手續費的股票中，覺得投資報酬率最高的投入剩餘現有現金的50%，第二高的再投入剩餘現有現金的50%，以此類推，並將剩餘所有的現有現金投入投資報酬率最低但還是認為能漲超過手續費的，然後隔天要將所有持有的股票都賣掉。認為會跌超過手續費的也是按照買股的方式，在認為跌超過手續費的股票中，覺得賣空的投資報酬率最高的就借價值約為現有現金的50%的券，賣空的投資報酬率第二高的再借價值約為剩餘現有現金的25%的券，以此類推，並在最後借與前一個同價值但還是認為能跌超過手續費的券，然後隔天也要將所有持有的股票都賣掉。隔天都會平倉。
- 可以全部都不買也不賣
The data set information and attribution information (6 years)¶
- stock:
- 0050 Yuanta Taiwan Top5: 0050 元大台灣50
- 0056 PTD: 0056 元大高股息
- 2317 Hon Hai Precision: 2317 鴻海
- 2330 TSMC: 2330 台積電
- 2454 MediaTek: 2454 聯發科
- 3008 Largan: 3008 大立光
- 2881 Fubon FHC: 2881 富邦金
- 2882 Cathay Holdings: 2882 國泰金
- 2884 E.S.F.H: 2884 玉山金
- 2885 Yuanta Group: 2885 元大金
- attribute:
- CO_ID: 公司代碼
- Date: 年月日
- Open(NTD): 開盤價(元)
- High(NTD): 最高價(元)
- Low(NTD): 最低價(元)
- Close(NTD): 收盤價(元)
- Volume(1000S): 成交量(千股)
- Amount(NTD1000): 成交值(千元)
- AVG CLOSE: 當日均價(元)
- AVG CLOSE 5D: 5日均價(元)
- AVG CLOSE 10D: 10日均價(元)
- AVG CLOSE 20D: 20日均價(元)
- AVG Vol 5D: 5日均量
- AVG Vol 10D: 10日均量
- AVG Vol 20D: 20日均量
- ROI%: 報酬率％
- Shares(1000S): 流通在外股數(千股)
- Market Cap.(NTD MN): 市值(百萬元)
- P/E-TEJ: 本益比-TEJ
- P/B-TEJ: 股價淨值比-TEJ
- Dividend_Yield%: 股利殖利率
- Cash_Dividend%: 現金股利率
- Price_Change(NTD): 股價漲跌(元)
- High minus Low %: 高低價差%
- Market: 上市別
- Capital: 資本
- No.of Employee: 員工人數
import every module I need¶
In [1]:
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
import math
np.seterr(divide='ignore', invalid='ignore')
Out[1]:
Gathering Data¶
online open dataset and some data parsers¶
- data source: TEJ, yahoo finance, apple stock
read data¶
In [2]:
stock_data = pd.read_csv('stock(eng).csv', encoding='utf-8', thousands=',')
print("dataset_shape = ", stock_data.shape)
Questionnaire surveys¶
各檔股票在50人中有聽過的次數¶
In [3]:
# 元大台灣50, 元大高股息, 鴻海, 台積電, 聯發科, 大立光, 富邦金, 國泰金, 玉山金, 元大金
reputation = [37, 15, 43, 49, 44, 20, 25, 26, 22, 24]
Define a Problem¶
- 起始金額為現金10,000元，希望最後能賺最多錢
- 每天都要判斷買多還是賣多這固定的十檔股票(0050、0056、鴻海、台積電、聯發科、大立光、富邦金、國泰金、玉山金、元大金)
- 自變數會用先前的開盤價、最高價、最低價、收盤價、成交量、5日均價、20日均價、網路聲量(如果有學會爬蟲的話)等等，而變數就是這十檔分別該買還是賣
- 假設想買一定買得到，想脫手一定賣得掉
- 假設股票能以前一天的收盤價買進，融券也是以前一天的收盤價為代價
- 假設手續費為交易金額的0.1%
- 先預測哪些會漲那些會跌之後，在認為漲超過手續費的股票中，覺得投資報酬率最高的投入剩餘現有現金的50%，第二高的再投入剩餘現有現金的50%，以此類推，並將剩餘所有的現有現金投入投資報酬率最低但還是認為能漲超過手續費的，然後隔天要將所有持有的股票都賣掉。認為會跌超過手續費的也是按照買股的方式，在認為跌超過手續費的股票中，覺得賣空的投資報酬率最高的就借價值約為現有現金的50%的券，賣空的投資報酬率第二高的再借價值約為剩餘現有現金的25%的券，以此類推，並在最後借與前一個同價值但還是認為能跌超過手續費的券，然後隔天也要將所有持有的股票都賣掉。隔天都會平倉。
- 可以全部都不買也不賣
- 預測哪些股票漲，哪些股票跌
- 預測正值前三高return的stock，之後買多。
- 預測負值前三高return的stock，之後賣空。
Data Processing has 3 parts¶
Data Processing - Part 1¶
encodings¶
Label Encoding¶
In [4]:
reputation = np.argsort(reputation) + 1
In [5]:
# 1402: 6 years
reputation = np.repeat(reputation, 1402)
In [6]:
stock_data['Reputation'] = reputation
In [7]:
stock_data.head()
Out[7]:
data clean-ups¶
In [8]:
print("is_any_null ", stock_data.isnull().values.any())
data preprocess for dropping column with lots of NaN and replacing NaN with mean¶
In [9]:
stock_data = stock_data.dropna(thresh=len(stock_data.index) * 0.8, axis=1)
stock_data = stock_data.fillna(stock_data.mean())
standardlization¶
observe the data¶
In [10]:
stock_data.min()
Out[10]:
In [11]:
stock_data.mean()
Out[11]:
normalization 限縮data的數量級，但因為是time series不能用 z-score standardlization¶
In [12]:
from sklearn.preprocessing import StandardScaler
In [13]:
min_too_big = stock_data._get_numeric_data().min() > 1000
min_too_big_attribute = set(min_too_big[min_too_big == True].index)
stock_data[list(min_too_big_attribute)] /= 1000
mean_too_large = stock_data.mean() > 1000000
mean_too_large_attribute = set(mean_too_large[mean_too_large == True].index)
stock_data[list(mean_too_large_attribute)] /= 1000000
mean_too_big = stock_data.mean() > 1000
mean_too_big_attribute = set(mean_too_big[mean_too_big == True].index)
stock_data[list(mean_too_big_attribute)] /= 1000
In [14]:
stock_data.mean()
Out[14]:
In [15]:
stock_data.head()
Out[15]:
In [16]:
stock_data.tail()
Out[16]:
Statistical Computing and Data Visualization¶
Statistical Computing¶
In [17]:
stock_data.info()
In [18]:
stock_data.describe()
Out[18]:
In [19]:
print(stock_data.nunique())
In [20]:
stock_data_cols = stock_data.columns
stock_data_cols_set = set(stock_data_cols)
stock_data_cols_list = list(stock_data_cols_set)
stock_data_continuous_variables_cols = stock_data._get_numeric_data().columns
stock_data_continuous_variables_cols_set = set(stock_data_continuous_variables_cols)
stock_data_continuous_variables_cols_list = list(stock_data_continuous_variables_cols_set)
print("stock_data_continuous_variables: ", stock_data_continuous_variables_cols_list)
stock_data_categorical_variables_cols_set = stock_data_cols_set - stock_data_continuous_variables_cols_set
stock_data_categorical_variables_cols_list = list(stock_data_categorical_variables_cols_set)
print("stock_data_categorical_variables:", stock_data_categorical_variables_cols_list)
frequency tables¶
In [21]:
[print(f'categorical variable: {i}\n{stock_data[i].value_counts()}\n') for i in stock_data_categorical_variables_cols_list]
Out[21]:
relative frequency tables¶
In [22]:
[print(f'categorical variable: {i}\n{stock_data[i].value_counts(normalize=True, sort=True)}\n') for i in stock_data_categorical_variables_cols_list]
Out[22]:
Data Visualization¶
bar plots¶
In [23]:
# [stock_data[i].value_counts().plot.bar(title=f'Freq dist of {i}') for i in stock_data_categorical_variables_cols_list]
for stock_data_categorical_variables_col in stock_data_categorical_variables_cols_list:
stock_data[stock_data_categorical_variables_col].value_counts().plot.bar()
plt.title(f'Freq dist of {stock_data_categorical_variables_col}')
plt.show()
histograms¶
In [24]:
for stock_data_continuous_variables_col in stock_data_continuous_variables_cols_list:
stock_data[stock_data_continuous_variables_col].hist(figsize= (8, 8), bins= 100)
plt.title(stock_data_continuous_variables_col)
plt.show()
distribution plots¶
In [25]:
stock_data_continuous_variables_cols_list_without_nan = []
for i in stock_data_continuous_variables_cols_list:
if stock_data[i].isnull().values.any() == False:
stock_data_continuous_variables_cols_list_without_nan.append(i)
fig, ax = plt.subplots(len(stock_data_continuous_variables_cols_list_without_nan), figsize=(16, 30))
for stock_data_idx, stock_data_continuous_variables_col in enumerate(stock_data_continuous_variables_cols_list_without_nan):
sns.distplot(stock_data[stock_data_continuous_variables_col], hist=True, ax=ax[stock_data_idx])
ax[stock_data_idx].set_title('Freq dist '+ stock_data_continuous_variables_col, fontsize=20)
ax[stock_data_idx].set_xlabel(stock_data_continuous_variables_col, fontsize=10)
ax[stock_data_idx].set_ylabel('Count', fontsize=10)
plt.show()
pairwise scatterplots¶
In [26]:
sns.pairplot(stock_data[stock_data_continuous_variables_cols_list])
plt.show()
heatmap¶
In [27]:
plt.figure(figsize=(10, 10))
sns.heatmap(stock_data.corr(), annot=False, center=0.0, cmap='coolwarm'); # cmap="YlGnBu",
plt.show()
Data Processing - Part 2¶
Datatype transformation and transform data format and shape so your model can process them.¶
create rolling window¶
observe a month to decide buy or sell¶
In [28]:
stock_type = set(stock_data[stock_data.columns[0]])
observe_date_long = 30
In [29]:
col_name = []
stock_data_list = []
Y = []
for s in stock_type:
col_name.append(s)
df = stock_data[stock_data[stock_data.columns[0]] == s]
df = df.dropna(axis='columns')
df = df.drop(columns=stock_data.columns[0])
df = df.drop(columns=stock_data.columns[1])
df = df.drop(columns='Market')
rep = np.unique(df['Reputation'])[0]
df = df.drop(columns='Reputation')
df = df.reset_index(drop=True)
Y.append(df['ROI%'].iloc[observe_date_long:])
df = df.drop(columns='ROI%')
df = df.reset_index(drop=True)
df_1 = df.copy()
for i in range(observe_date_long - 1):
df_new = df_1.drop(df_1.index[0], inplace=False)
df_new = df_new.append(df_1.iloc[-1])
df_1 = df_1.reset_index(drop=True)
df_new = df_new.reset_index(drop=True)
df_1 = df_new.copy()
df = pd.concat([df, df_1], axis=1)
df['Reputation'] = rep
df = df.drop(df.index[:observe_date_long], inplace=False)
stock_data_list.append(df)
In [30]:
stock_data_roll_window = stock_data_list[0]
for i in range(len(stock_data_list) - 1):
stock_data_roll_window = pd.concat([stock_data_roll_window, stock_data_list[i + 1]], axis=0)
In [31]:
X = stock_data_list.copy()
generate train data and test data¶
test for a month¶
In [32]:
train_x = []
test_x = []
train_y = []
test_y = []
n_test = 30
for i in range(len(stock_type)):
train_x.append(X[i].iloc[:-n_test])
test_x.append(X[i].iloc[-n_test:])
train_y.append(Y[i][:-n_test])
test_y.append(Y[i][-n_test:])
In [33]:
train_x_roll_window = train_x[0]
test_x_roll_window = test_x[0]
train_y_roll_window = train_y[0]
test_y_roll_window = test_y[0]
for i in range(len(train_x) - 1):
train_x_roll_window = pd.concat([train_x_roll_window, train_x[i + 1]], axis=0)
test_x_roll_window = pd.concat([test_x_roll_window, test_x[i + 1]], axis=0)
train_y_roll_window = pd.concat([train_y_roll_window, train_y[i + 1]], axis=0)
test_y_roll_window = pd.concat([test_y_roll_window, test_y[i + 1]], axis=0)
train_x = train_x_roll_window
test_x = test_x_roll_window
train_y = np.array(train_y_roll_window)
test_y = np.array(test_y_roll_window)
Data Processing - Part 3¶
transform data format and shape so your model can process them.¶
Data analysis - PCA for SVM¶
import module¶
In [34]:
from sklearn.decomposition import PCA
In [36]:
n_com = 10
explained_ratio = 0
explained_ratio_threshold = 90
for i in range(len(stock_type)):
covar_matrix = PCA(n_components = n_com)
# calculate variance ratios
covar_matrix.fit(X[i])
cumulative_sum_of_variance_explained = np.cumsum(np.round(covar_matrix.explained_variance_ratio_, decimals=4) * 100)
explained_ratio = cumulative_sum_of_variance_explained[-1]
while explained_ratio < explained_ratio_threshold:
n_com += 1
covar_matrix = PCA(n_components = n_com)
# calculate variance ratios
covar_matrix.fit(X[i])
cumulative_sum_of_variance_explained = np.cumsum(np.round(covar_matrix.explained_variance_ratio_, decimals=4) * 100)
explained_ratio = cumulative_sum_of_variance_explained[-1]
In [37]:
X_pca = []
for i in range(len(stock_type)):
pca = PCA(n_components = n_com)
principalComponents = pca.fit_transform(X[i])
print(col_name[i], 'explained variance ratio:', np.sum(pca.explained_variance_ratio_))
X_pca.append(pd.DataFrame(data = principalComponents))
In [38]:
train_x_pca = []
test_x_pca = []
n_test = 30
for i in range(len(stock_type)):
train_x_pca.append(X_pca[i].iloc[:-n_test])
test_x_pca.append(X_pca[i].iloc[-n_test:])
In [39]:
train_x_pca_roll_window = train_x_pca[0]
test_x_pca_roll_window = test_x_pca[0]
for i in range(len(train_x_pca) - 1):
train_x_pca_roll_window = pd.concat([train_x_pca_roll_window, train_x_pca[i + 1]], axis=0)
test_x_pca_roll_window = pd.concat([test_x_pca_roll_window, test_x_pca[i + 1]], axis=0)
train_x_pca = train_x_pca_roll_window
test_x_pca = test_x_pca_roll_window
Shuffle the data.¶
import module¶
In [40]:
from sklearn.utils import shuffle
In [41]:
train_x, train_x_pca, train_y = shuffle(train_x, train_x_pca, train_y, random_state=0)
Building Models¶
model - linear regression¶
import module¶
In [42]:
from sklearn import linear_model
import statsmodels.api as sm
In [43]:
#Fit the linear regression.
regr = linear_model.LinearRegression()
regr = regr.fit(train_x, train_y)
#Print the coefficient.
print('intercept:', regr.intercept_)
print('coef:', regr.coef_)
In [44]:
X_OLS = sm.add_constant(train_x)
train_y = list(train_y)
model = (sm.OLS(train_y, X_OLS).fit())
model - SVM¶
import module¶
In [45]:
from sklearn.svm import LinearSVR
In [46]:
svm = LinearSVR()
svm = svm.fit(train_x_pca, train_y)
model - DNN¶
import module¶
In [47]:
import keras
In [48]:
model = keras.models.Sequential()
model.add(keras.layers.Dense(10, activation="selu"))
model.add(keras.layers.Dense(10, activation='relu'))
model.add(keras.layers.Dense(1))
model.compile(loss="mse", optimizer="adam", metrics=['mae'])
model.fit(np.array(train_x_pca), np.array(train_y), batch_size=256, epochs=20)
Out[48]:
Test¶
long-buy and short-sell¶
In [49]:
def long(test_day, n_test, stock_type1, stock_type2, stock_type3, money):
buy = 0.5 * money
transection_fee = 0.1 / 100
ROI_1 = test_y[test_day + stock_type1 * n_test] / 100
ROI_2 = test_y[test_day + stock_type2 * n_test] / 100
ROI_3 = test_y[test_day + stock_type3 * n_test] / 100
if ROI_3 > transection_fee:
money += 0.5 * buy * ROI_1
money += 0.5 * 0.5 * buy * ROI_2
money += 0.5 * 0.5 * buy * ROI_3
money -= transection_fee * buy
# print('ROI:', ROI_1, ROI_2, ROI_3)
elif ROI_2 > transection_fee:
money += 0.5 * buy * ROI_1
money += 0.5 * buy * ROI_2
money -= transection_fee * buy
# print('ROI:', ROI_1, ROI_2)
elif ROI_1 > transection_fee:
money += buy * ROI_1
money -= transection_fee * buy
# print('ROI:', ROI_1)
print('money since long:', money)
return money
def short(test_day, n_test, stock_type1, stock_type2, stock_type3, money):
sell = 0.5 * money
transection_fee = 0.1 / 100
ROI_1 = test_y[test_day + stock_type1 * n_test] / 100
ROI_2 = test_y[test_day + stock_type2 * n_test] / 100
ROI_3 = test_y[test_day + stock_type3 * n_test] / 100
if ROI_3 < -transection_fee:
money -= 0.5 * sell * ROI_1
money -= 0.5 * 0.5 * sell * ROI_2
money -= 0.5 * 0.5 * sell * ROI_3
money -= transection_fee * sell
# print('ROI:', ROI_1, ROI_2, ROI_3)
elif ROI_2 < -transection_fee:
money -= 0.5 * sell * ROI_1
money -= 0.5 * sell * ROI_2
money -= transection_fee * sell
# print('ROI:', ROI_1, ROI_2)
elif ROI_1 < -transection_fee:
money -= sell * ROI_1
money -= transection_fee * sell
# print('ROI:', ROI_1)
print('money since short:', money)
return money
In [50]:
money_std = 10000
In [51]:
def money_gain(n_test, pred_y, money_begin):
money = money_begin
print('day 0')
print('money initial:', money)
for test_day in range(n_test):
pred_i = pred_y[test_day : : n_test]
sort_idx = np.argsort(pred_i)
print('day', test_day + 1)
money = long(test_day, n_test, sort_idx[-1], sort_idx[-2], sort_idx[-3], money)
money = short(test_day, n_test, sort_idx[0], sort_idx[1], sort_idx[2], money)
return money
linear regression¶
In [52]:
pred_y_regr = regr.predict(test_x)
print('predict rate of return:')
print(pred_y_regr)
In [53]:
money_regr = money_std
pred_y_regr = np.array(pred_y_regr)
money_regr = money_gain(n_test, pred_y_regr, money_regr)
In [54]:
print('final money with linear regression:', money_regr)
SVM¶
In [55]:
pred_y_svm = svm.predict(test_x_pca)
print('predict rate of return:')
print(pred_y_svm)
In [56]:
money_svm = money_std
pred_y_svm = np.array(pred_y_svm)
money_svm = money_gain(n_test, pred_y_svm, money_svm)
In [57]:
print('final money with svm:', money_svm)
DNN¶
In [58]:
pred_y_dnn = model.predict(test_x_pca).flatten()
print('predict rate of return:')
print(pred_y_dnn)
In [59]:
money_dnn = money_std
pred_y_dnn = np.array(pred_y_dnn)
money_dnn = money_gain(n_test, pred_y_dnn, money_dnn)
In [60]:
print('final money with dnn model:', money_dnn)
Result¶
In [61]:
def get_label(n_test, y):
label = []
for test_day in range(n_test):
sort_idx = y[test_day : : n_test]
label.append(np.argsort(sort_idx))
label = np.array(label).flatten()
return label
In [62]:
def get_mse(test_y, pred_y):
mse = ((test_y - pred_y) ** 2).mean()
return mse
final money¶
In [63]:
print('final money with linear regression:', money_regr)
print('final money with svm:', money_svm)
print('final money with dnn model:', money_dnn)
Confusion matrix, Accuracy, Sensitivity(Recall), Precision¶
In [64]:
test_label = get_label(n_test, test_y)
pred_label_regr = get_label(n_test, pred_y_regr)
pred_label_svm = get_label(n_test, pred_y_svm)
pred_label_dnn = get_label(n_test, pred_y_dnn)
import module¶
In [65]:
from sklearn.metrics import confusion_matrix
from sklearn.metrics import accuracy_score, recall_score, precision_score
In [66]:
print('Confusion matrix')
print('linear regression:', confusion_matrix(test_label, pred_label_regr), sep='\n')
print('SVM:', confusion_matrix(test_label, pred_label_svm), sep='\n')
print('DNN:', confusion_matrix(test_label, pred_label_dnn), sep='\n')
print('Accuracy')
print('linear regression:', accuracy_score(test_label, pred_label_regr))
print('SVM:', accuracy_score(test_label, pred_label_svm))
print('DNN:', accuracy_score(test_label, pred_label_dnn))
print('Sensitivity(Recall)')
print('linear regression:', recall_score(test_label, pred_label_regr, average=None))
print('SVM:', recall_score(test_label, pred_label_svm, average=None))
print('DNN:', recall_score(test_label, pred_label_dnn, average=None))
print('Precision')
print('linear regression:', precision_score(test_label, pred_label_regr, average=None))
print('SVM:', precision_score(test_label, pred_label_svm, average=None))
print('DNN:', precision_score(test_label, pred_label_dnn, average=None))
print('Mean Square Error')
print('linear regression:', get_mse(test_y, pred_y_regr))
print('SVM:', get_mse(test_y, pred_y_svm))
print('DNN:', get_mse(test_y, pred_y_dnn))
In [69]:
print('\t\t\tlinear regression', 'SVM', '\tDNN', sep='\t\t\t')
print('Accuracy:\t\t', accuracy_score(test_label, pred_label_regr),'\t\t\t', accuracy_score(test_label, pred_label_svm), '\t\t\t\t', accuracy_score(test_label, pred_label_dnn))
print('Sensitivity(Recall):\t', recall_score(test_label, pred_label_regr, average='weighted'),'\t\t\t', recall_score(test_label, pred_label_svm, average='weighted'), '\t\t\t\t', recall_score(test_label, pred_label_dnn, average='weighted'))
print('Precision:\t\t', precision_score(test_label, pred_label_regr, average='weighted'),'\t\t\t', precision_score(test_label, pred_label_svm, average='weighted'), '\t\t\t\t', precision_score(test_label, pred_label_dnn, average='weighted'))
print('Mean Square Error\t', get_mse(test_y, pred_y_regr),'\t\t\t', get_mse(test_y, pred_y_svm), '\t\t', get_mse(test_y, pred_y_dnn))
Conclusion & Application¶
- DNN > SVM > linear regression
Division of labor¶
- 0616098黃秉茂 - 44%
- 0616031李昀奇 - 28%
- 0616309王祥任 - 28%